13 设计模式——迭代器模式

返回设计模式博客目录

介绍

迭代器（Iterator）模式：提供一种方法顺序访问一个容器对象中的各个元素，而又不需暴露该对象的内部细节。

在程序设计中，经常要访问一个聚合对象中的各个元素，如数据结构中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。

既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：暴露了聚合类的内部表示，使其数据不安全；增加了客户的负担。

迭代器模式能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

优点

访问一个聚合对象的内容而无须暴露它的内部表示。
遍历任务交由迭代器完成，这简化了聚合类。
它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
增加新的聚合类和迭代器类都很方便，无须修改原有代码。
封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点

增加了类的个数，这在一定程度上增加了系统的复杂性。

使用场景

遍历一个容器对象时。

结构与实现

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。现在我们来分析其基本结构与实现方法。

模式包含以下主要角色。

Iterator（迭代器接口）：负责定义、访问和遍历元素的接口。
ConcreteIterator（具体迭代器类）：实现迭代器接口。
Aggregate（容器接口）：定义容器的基本功能以及提供创建迭代器的接口。
ConcreteAggregate（具体容器类）：实现容器接口中的功能。
Client（客户端类）：即要使用迭代器模式的地方。

其结构图如下图所示：

代码如下：

public class IteratorPattern {
    public static void main(String[] args) {
        Aggregate<String> aggregate = new ConcreteAggregate<>(); 
        aggregate.add("中山大学"); 
        aggregate.add("华南理工"); 
        aggregate.add("韶关学院");
        System.out.print("聚合的内容有：");
        Iterator<String> it = aggregate.getIterator(); 
        while (it.hasNext()) {
            System.out.print(it.next() + "\t"); 
        }
        System.out.println("\nFirst：" + it.first());
    }
}
// 抽象聚合
interface Aggregate<T> { 
    void add(T obj); 
    void remove(T obj); 
    Iterator<T> iterator(); 
}
// 具体聚合，具体容器
class ConcreteAggregate<T> implements Aggregate<T> { 
    private List<T> list = new ArrayList<T>(); 
    public void add(T obj) { 
        list.add(obj); 
    }
    public void remove(T obj) { 
        list.remove(obj); 
    }
    public Iterator<T> getIterator() { 
        return(new ConcreteIterator<T>(list)); 
    }     
}
// 抽象迭代器
interface Iterator<T> {
    T first();
    T next();
    boolean hasNext();
}
// 具体迭代器
class ConcreteIterator<T> implements Iterator<T> { 
    private List<T> list; 
    private int index = -1; 
    public ConcreteIterator(List<T> list) { 
        this.list = list; 
    } 
    public boolean hasNext() { 
        return index < list.size() - 1;
    }
    public T first() {
        index = 0;
        return list.get(index);
    }
    public T next() { 
        T obj = null; 
        if (this.hasNext()) { 
            obj = list.get(++index); 
        } 
        return obj; 
    }   
}

示例

用迭代器模式编写一个浏览婺源旅游风景图的程序。

分析：婺源的名胜古迹较多，要设计一个查看相关景点图片和简介的程序，用“迭代器模式”设计比较合适。

首先，设计一个婺源景点（WyViewSpot）类来保存每张图片的名称与简介；再设计一个景点集（ViewSpotSet）接口，它是抽象聚合类，提供了增加和删除婺源景点的方法，以及获取迭代器的方法。

然后，定义一个婺源景点集（WyViewSpotSet）类，它是具体聚合类，用 ArrayList 来保存所有景点信息，并实现父类中的抽象方法；再定义婺源景点的抽象迭代器（ViewSpotltemtor）接口，其中包含了查看景点信息的相关方法。

最后，定义婺源景点的具体迭代器（WyViewSpotlterator）类，它实现了父类的抽象方法。

程序代码如下：

// 婺源景点类
class WyViewSpot {
    private String name;
    private String introduce;
    WyViewSpot(String name, String Introduce) {
        this.name = name;
        this.introduce = introduce;
    }
    public String getName() {
        return name;
    }
    public String getIntroduce() {
        return introduce;
    }
}
// 抽象聚合：婺源景点集接口
interface ViewSpotSet {
    void add(WyViewSpot obj);
    void remove(WyViewSpot obj);
    ViewSpotIterator iterator();
}
// 具体聚合：婺源景点集
class WyViewSpotSet implements ViewSpotSet {
    private List<WyViewSpot> list = new ArrayList<>();
    public void add(WyViewSpot obj) {
        list.add(obj);
    }
    public void remove(WyViewSpot obj) {
        list.remove(obj);
    }
    public ViewSpotIterator iterator() {
        return(new WyViewSpotIterator(list));
    }
}
// 抽象迭代器：婺源景点迭代器接口
interface ViewSpotIterator {
    boolean hasNext();
    WyViewSpot next();
}
// 具体迭代器：婺源景点迭代器
class WyViewSpotIterator implements ViewSpotIterator {
    private List<WyViewSpot> list;
    private int index = -1;
    public WyViewSpotIterator(List<WyViewSpot> list) {
        this.list = list;
    }
    public boolean hasNext() {
        return index < list.size() - 1;
    }
    public WyViewSpot next() {
        return list.get(++index);
    }
}

由于聚合与迭代器的关系非常密切，所以大多数语言在实现聚合类时都提供了迭代器类，因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。

ANDROID 源码中的实现

ANDROID 中典型的迭代器模式例子是数据库查询使用 Cursor，当我们使用 SQLiteDatabase 的 query 方法查询数据时，会返回一个 Cursor 游标对象，该游标对象实质就是一个具体的迭代器，我们可以使用它遍历数据库查询所得到的结果集。

首先定义一个 SQLiteOpenHelper：

public class DBHelper extends SQLiteOpenHelper {
    public DBHelper(Context context) {
        super(context, "DB_AIGE", null, 1);
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE table_aige (_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, sex TEXT)");
        db.execSQL("INSERT INTO table_aige (name, sex) values ('Aige', 'man')");
        db.execSQL("INSERT INTO table_aige (name, sex) values ('SMBrother', 'man')");
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}

构造 ContentProvider：

public class DataProvider extends ContentProvider {
    private DBHelper dbHelper;
    @Override
    public boolean onCreate() {
        dbHelper = new DBHelper(getContext());
        return true;
    }
    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        return db.query("table_aige", projection, null, null, null, null, null);
    }
    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        return null;
    }
    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        return null;
    }
    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
        return 0;
    }
    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
        return 0;
    }
}

在 Activity 使用 ContentProvider：

public class IteratorActivity extends ListActivity {
    private static final Uri URI = Uri.parse("content://com.android.androidsamples.dataprovider/table_aige");
    private static final String[] PROJECTION = new String[]{"name", "sex"};
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Cursor cursor = getContentResolver().query(URI, PROJECTION, null, null, null);
        List<Map<String, String>> list = new ArrayList<>();
        cursor.moveToFirst();
        do {
            Map<String, String> item = new HashMap<>();
            item.put("name", cursor.getString(0));
            item.put("sex", cursor.getString(1));
            list.add(item);
        } while (cursor.moveToNext());
        cursor.close();
        setListAdapter(new SimpleAdapter(this, list, android.R.layout.simple_list_item_2,
                new String[]{"name", "sex"}, new int[]{android.R.id.text1, android.R.id.text2}));
    }
}

注册组件：

1
2
3

<activity android:name=".iterator.IteratorActivity" />
<provider android:authorities="com.android.androidsamples.dataprovider" 
        android:name=".iterator.DataProvider"/>